#!/usr/bin/env python
# -*-coding: utf-8 -*-
# Filename: buscar_grupo.py

##
# Módulos del sistema
# Parte gráfica
try:
    import pygtk
    pygtk.require("2.0")
    import gtk
    import gtk.glade
except ImportError, error:
    print error
    print "Necesitas la librería gráficas gtk+pygtk"

# Utilidades
from datetime import datetime
from sqlobject.sqlbuilder import LIKE, AND


##
# Módulos propios
try:
    from msj_retroalimentacion import MensajeDeError, MensajeDeAdvertencia
    from lib.funciones_utiles import close, add_find_column
    from lib.database import GrupoDeResolucion, Empleado
    from gui.detalle_grupo import DetalleDeGrupoDeResolucion
    from gui.modificar_grupo import ModificarGrupoDeResolucion
except ImportError, error:
    print error
    print "Error en buscar_grupo.py"

class BuscarGrupoDeResolucion:
    def __init__(self, padre):
        self.gladefile = "gui/ghhp.glade"
        self.wTree = gtk.glade.XML(self.gladefile, "BuscarGrupoDeResolucion")
        self.window = self.wTree.get_widget("BuscarGrupoDeResolucion")
        self.wTree.get_widget("dialog-action_area12").hide()#Botonera par desp.
        self.un_dict ={"on_button35_clicked": self.buscar_grupos,
                "on_button36_clicked": self.limpiar_campos,
                "on_button39_clicked": self.close,
                "on_applybutton4_clicked": self.modificar_grupo,
                "on_cancelbutton10_clicked": self.borrar_grupo,
                "on_okbutton11_clicked": self.aceptar,
                "on_button28_clicked": self.close,
                "on_button1_clicked": self.detalle_grupo}
        self.wTree.signal_autoconnect(self.un_dict)
        # Variables
        self.hbox_55 = self.wTree.get_widget("hbox55")
        self.hbox_13 = self.wTree.get_widget("hbox13")
        self.botonera_arriba = self.wTree.get_widget("hbuttonbox30")
        self.botonora_abajo = self.wTree.get_widget("dialog-action_area12")
        self.tree_grupos = self.wTree.get_widget("treeview12")
        self.lista_resultado = gtk.ListStore(str, str, str)
        self.tree_grupos.set_model(self.lista_resultado)
        self.entry_codigo_grupo = self.wTree.get_widget("entry57")
        self.entry_nombre_grupo = self.wTree.get_widget("entry58")
        self.combo_estado_grupo = self.wTree.get_widget("combobox2")
        self.entry_legajo_integrante = self.wTree.get_widget("entry59")
        self.entry_apellido_integrante = self.wTree.get_widget("entry60")
        self.entry_nombre_integrante = self.wTree.get_widget("entry21")
        self.check_todos = self.wTree.get_widget("checkbutton10")
        self.lista_grupos = []
        self.armar_combo()
        self.armar_lista_resultado()


    def armar_lista_resultado(self):
        titulos = ["Código", "Nombre", "Estado"]
        for pos, titulo in enumerate(titulos):
            add_find_column(titulo, pos, self.tree_grupos)
    
    def armar_combo(self):
        estados = ['',"Activo", "Inactivo"]
        for estado in estados:
            self.combo_estado_grupo.append_text(estado)
        self.combo_estado_grupo.set_active(0)
        
    def buscar_grupos(self, widget):
        """Busca los grupos dependiendo de la cantidad de criterios pasados"""
        if self.check_todos.get_active():
            # Trae todos los grupos
            resultado = GrupoDeResolucion.select()
            if list(resultado):
                self.mostrar_resultado(list(resultado))
            else:
                error = ["No existen grupos en el sistema que cumplan",
                        "con lo criterios seleccionados"]
                msj = MensajeDeError("\n".join(error), self.window)
                msj.run()
                self.limpiar_campos(None)
        else:
            # Probamos haciendo una tupla, en vez de lista. Es mas rápido y ya
            # conocemos todos los valores... probemos
            resultado_grupo = self.consulta_grupo()
            resultado_integrante = self.consulta_integrante()
            # Probando
            self.imprimir_en_consola(resultado_grupo, resultado_integrante)
            if (resultado_grupo == [] and resultado_integrante == []):
                error = ["No existen grupos en el sistema que cumplan",
                        "con lo criterios seleccionados"]
                msj = MensajeDeError("\n".join(error), self.window)
                msj.run()
                self.limpiar_campos(None)
            else:
                self.mostrar_resultado(resultado_grupo, resultado_integrante)
    
    def imprimir_en_consola(self, resultado_grupo, resultado_integrante):
        if resultado_grupo:
            print 'Consulta Grupo'
            for grupo in resultado_grupo:
                print "Id %d - Nombre: %s - Estado: %s" % (grupo.id,
                        grupo.nombre, grupo.estado)
        if resultado_integrante:
            for grupo in resultado_integrante:
                print "Id %d - Nombre: %s - Estado: %s" % (grupo.id,
                        grupo.nombre, grupo.estado)

    def consulta_integrante(self):
        """Armara la consulta dependiendo de los criterios del integrante
        solicitado"""
        legajo_integrante = self.entry_legajo_integrante.get_text()
        nombre_integrante = self.entry_nombre_integrante.get_text()
        apellido_integrante = self.entry_apellido_integrante.get_text()
        tupla_widget_integrante = (legajo_integrante,
                nombre_integrante,
                apellido_integrante)
        print "Tupla integrantes"
        print tupla_widget_integrante
        consulta_widget_integrante =(
                LIKE(Empleado.q.legajo, '%'+legajo_integrante+'%'),
                LIKE(Empleado.q.nombre, '%'+nombre_integrante+'%'),
                LIKE(Empleado.q.apellido, '%'+apellido_integrante+'%')
                )
        consulta_integrante = ''
        lista_grupos = []
        for pos, dato in enumerate(tupla_widget_integrante):
            if dato:
                consulta_integrante+= consulta_widget_integrante[pos]
        if consulta_integrante:
            resultado_integrante = Empleado.select(AND(consulta_integrante))
            # Como no tengo relacion directa entre empleado y grupo, para
            # obtener el grupo de resolucion recorro resultado_integrante y
            # devuelvo el grupo del usuario asociado
            for empleado in resultado_integrante:
                if empleado.usuario:
                    lista_grupos.append(empleado.usuario.grupo_de_resolucion)
        return lista_grupos

    def consulta_grupo(self):
        """Armara la consulta dependiendo de los criterios del grupo ingresados"""
        codigo_grupo = self.entry_codigo_grupo.get_text()
        nombre_grupo = self.entry_nombre_grupo.get_text()
        if self.combo_estado_grupo.get_active_text() == "Activo":
            estado_grupo = True
        elif self.combo_estado_grupo.get_active_text() == "Inactivo":
            estado_grupo = False
        else:
            estado_grupo = ''
        tupla_widget_grupo = (codigo_grupo,
                    nombre_grupo,
                    estado_grupo)
        print "Tupla grupos"
        print tupla_widget_grupo
        consulta_widget_grupo =(
                LIKE(GrupoDeResolucion.q.id,'%'+codigo_grupo+'%'),
                LIKE(GrupoDeResolucion.q.nombre,'%'+nombre_grupo+'%'),
                LIKE(GrupoDeResolucion.q.estado, estado_grupo)
                )
        consulta_grupo = ''
        lista_grupos = []
        for pos, dato in enumerate(tupla_widget_grupo):
            if dato:
                consulta_grupo+=consulta_widget_grupo[pos]
        if consulta_grupo:
            # El usuario puso al menos un criterio relacionado al grupo
            lista_grupos = GrupoDeResolucion.select(AND(consulta_grupo))
        return list(lista_grupos)

    def mostrar_resultado(self, resultado_grupo, resultado_integrantes=None):
        # La usamos para comprobar si hubo coincidencias
        bandera_grupo = False
        bandera_integrante = False
        # Solo criterios del grupo ó TODOS
        if resultado_grupo:
            for grupo in resultado_grupo:
                self.lista_grupos.append(grupo)
                if grupo.estado:
                    estado_grupo = "Activo"
                else:
                    estado_grupo = "Inactivo"
                self.lista_resultado.append([grupo.id,
                    grupo.nombre,
                    estado_grupo])
            bandera_grupo = True
        # Si el usuario puso criterios de los integrantes
        if resultado_integrantes:
            for integrante in resultado_integrantes:
                self.lista_grupos.append(integrante.grupo_de_resolucion)
                if integrante.grupo_de_resolucion.estado:
                    estado_grupo = "Activo"
                else:
                    estado_grupo = "Inactivo"
                self.lista_resultado.append([integrante.grupo_de_resolucion.id,
                    integrante.grupo_de_resolucion.nombre,
                    integrante.grupo_de_resolucion.apellido])
        # Hacemos visible el resultado        
        self.colocar_criterios_de_busqueda()
        self.hbox_55.hide()
        self.botonera_arriba.hide()
        self.hbox_13.show()
        self.botonora_abajo.show()
        self.window.resize(500, 350)
    
    def colocar_criterios_de_busqueda(self):
        """Pone en el área de resultado los criterios que fueron colocados"""
        labels = ("label231", "label232", "label242", "label247",
                "label248", "label249")
        datos = (self.entry_codigo_grupo.get_text(),
                self.entry_nombre_grupo.get_text(),
                 self.combo_estado_grupo.get_active_text(),
                 self.entry_legajo_integrante.get_text(),
                 self.entry_apellido_integrante.get_text(),
                 self.entry_nombre_integrante.get_text())
        for pos, label in enumerate(labels):
            self.wTree.get_widget(label).set_text(datos[pos])

    def limpiar_campos(self, widget):
        entrys = [self.entry_codigo_grupo, self.entry_nombre_grupo,
                self.entry_legajo_integrante, self.entry_apellido_integrante,
                self.entry_nombre_integrante]
        for entry in entrys:
            entry.set_text('')
        self.combo_estado_grupo.set_active(0)
        self.check_todos.set_active(False)

    def close(self, widget):
        close(self.window)

    def detalle_grupo(self, widget):
        """Despliega la informacion requerida del grupo"""
        model, path = self.tree_grupos.get_selection().get_selected_rows()
        if path:
            pos, = path[0]
            self.detalles = DetalleDeGrupoDeResolucion(self,
                self.lista_grupos[pos])
        else:
             error = "Para ver el detalle del grupo debe seleccionarlo"
             msj = MensajeDeError(error, self.window)
             msj.run()

    def modificar_grupo(self, widget):
        model, path = self.tree_grupos.get_selection().get_selected_rows()
        if path:
            pos, = path[0]
            self.detalles = ModificarGrupoDeResolucion(self,
                self.lista_grupos[pos])
        else:
             error = "Para modificar el grupo debe seleccionarlo"
             msj = MensajeDeError(error, self.window)
             msj.run()


    def borrar_grupo(self, widget):
        pass

    def aceptar(self, widget):
        self.hbox_55.show()
        self.botonera_arriba.show()
        self.hbox_13.hide()
        self.botonora_abajo.hide()
        self.window.resize(450, 250)
        self.lista_resultado.clear()
        self.limpiar_campos(None)
